#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <cstring>
#include <string>
#include <cstdio>
#include <thread>
using namespace std;

string toHex(pthread_t id)
{
    char buff[1024];
    snprintf(buff, sizeof(buff), "%p", id);
    return buff;
}

void *threadRoutine(void *args)
{
    int cnt=1;
    while (true)
    {
        cout << "thread_id :" << toHex(pthread_self()) << endl;
        sleep(1);
        if(cnt==1) break;
    }
    return nullptr;
}

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid,nullptr,threadRoutine,(void*)"Thread-1 ");

//     cout<<"main thread creat thread done,tid: "<<toHex(tid)<<endl;
//     pthread_join(tid,0);
//     return 0;
// }
 
//id是在堆栈之间的
int g_val;
int g_val2 = 100;
int main(int argc, char *argv[], char *env[])
{
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void *)"Thread-1 ");

    cout << "main thread creat thread done,tid: " << toHex(tid) << endl;
    pthread_join(tid, 0);
    printf("code addr:%p\n", main);
    const char *str = "hello";
    printf("only read string addr:%p\n", str);
    printf("uninit gable value addr:%p\n", &g_val);
    printf("init gable value addr:%p\n", &g_val2);
    char *mem = (char *)malloc(100);
    char *mem1 = (char *)malloc(100);
    char *mem2 = (char *)malloc(100);
    printf("heap addr:%p\n", mem);
    printf("heap addr:%p\n", mem1);
    printf("heap addr:%p\n", mem2);
    printf("stack addr:%p\n", &str);
    printf("stack addr:%p\n", &mem);
    static int a = 0;
    int b;
    int c;
    printf("a= stack addr:%p\n", &a);
    printf("stack addr:%p\n", &b);
    printf("stack addr:%p\n", &c);
    int i = 0;
    for (; argv[i]; i++)
    {
        printf("argv[%d]:%p\n", i, argv[i]);
    }
    for (i = 0; env[i]; i++)
    {
        printf("env[%d]:%p\n", i, env[i]);
    }

    return 0;
}

// void*threadrun()
// {
//     while(true)
//     {
//         cout<<"I am a new thread "<<endl;
//         sleep(1);
//     }
// }
// //c++的线程库
// int main()
// {
//     thread t1(threadrun);

//     t1.join();
//     return 0;
// }

// class ThreadTask
// {
// public:
//     class Request
//     {
//     public:
//         Request(int start, int end, string threadname)
//             : _start(start), _end(end), _threadname(threadname)
//         {
//         }

//     public:
//         int _start;
//         int _end;
//         string _threadname;
//     };

//     class Response
//     {
//     public:
//         Response(int result, int exitcode)
//             : _result(result), _exitcode(exitcode)
//         {
//         }

//     public:
//         int _result;
//         int _exitcode; // 结果是否可靠？
//     };

//     //静态成员函数才能被调用
//     static void* sumcount(void*args)
//     {
//         ThreadTask::Request* rq=static_cast<ThreadTask::Request*>(args);  //Request*rq=(Request*)args;
//         ThreadTask::Response* rsp=new ThreadTask::Response(0,0);
//         for(int i=rq->_start;i<rq->_end;i++)
//         {
//             cout<<rq->_threadname<<" is runing ,"<<"caling"<<i<<endl;
//             rsp->_result +=i;
//             // cout<<rsp->_result<<endl;

//             usleep(100000);
//         }
//         // delete(rsp);
//         // delete(rq);

//         return rsp;
//     }
// };

// int main()
// {
//     ThreadTask::Request task(1,10,"Thread_1");
//     //ThreadTask::sumcount;
//     pthread_t tid;
//     pthread_create(&tid,nullptr,ThreadTask::sumcount,&task);

//     void*ret;
//     pthread_join(tid,&ret);
//     ThreadTask::Response* rsp=static_cast<ThreadTask::Response*>(ret);
//     cout<<"rsp->_result: "<<rsp->_result<<"  rsp->exitcode: "<<rsp->_exitcode<<endl;
//     delete rsp;
//     return 0;
// }

// //可以多个执行流进入并同时执行，函数可重入噢
// int g_val=100;

// void show(const string&name)
// {
//     cout<<name<<"say# "<<"hello new thread"<<endl;
// }

// void* threadRoutine(void*args)
// {
//     const char* name=(const char*)args;
//     int cnt=5;
//     while(true)
//     {
//         printf("%s,  pid: %d, g_val: %d, &g_val: 0x%p\n", name,getpid(), g_val, &g_val);
//         // show("[new thread]");
//         sleep(1);
//         // int a=10;
//         // a/=0;
//         cnt--;
//         g_val++;
//         if(cnt==0)
//             break;
//     }
//     //直接用来终止进程的，而不能用来终止线程
//     // exit(11);

//     pthread_exit((void*)1);
//     // return (void*)1;  //走到这里，线程默认退出
// }

// int main()
// {
//     PTHREAD_CANCELED;

//     pthread_t tid;
//     pthread_create(&tid,nullptr,threadRoutine,(void*)"Thread 1");
//     sleep(1);
//     // pthread_cancel(tid);
//     // while(true)
//     // {
//     //     printf("main thread pid: %d, g_val: %d, &g_val: 0x%p, create new thread tid: %p\n", getpid(), g_val, &g_val, tid);
//     //     // show("[main thread]");
//     //     sleep(1);
//     //     g_val++;
//     // }
//     void* reval;
//     pthread_join(tid,&reval);
//    // if ( reval == PTHREAD_CANCELED )
//         cout<<"main join quit... , reval:  "<<(long long int)reval<<endl;
//     return 0;
// }

// void* threadRun(void*args)
// {
//     while(true)
//     {
//         cout<<"hello threadRun "<<endl;
//         sleep(2);
//     }
//     return nullptr;
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid,nullptr,threadRun,0);

//     while(true)
//     {
//         cout<<"I runing main thread"<<endl;
//         sleep(1);
//     }
//     return 0;
// }